/*
Copyright (c) [2019年5月1日] [吴超]
[MBT_Studio] is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
		 http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/
#include "stdafx.h"
#include "ui属性栏.h"

#include <面/Surface.h>
#include <UI/布局.h>

#include "A_引擎/引擎.h"

#include "节点视口/ui插座编辑列表.h"
#include "框架/工作区/通用弹出菜单.h"
#include "框架/设置部件窗口.h"
#include "框架/工作区/工作区.h"
#include "B_场景管理/节点管理.h"



//#define DEF_行文本_路径字符分配最大数量 128
//#define DEF_行文本_数值字符分配最大数量 10

static float32 g状态栏高度 = 24;
static float32 g_值部件大小 = 22;

static float32 g两边间隙 = 4;
static float32 g上下间隙 = 24;
static float32 g左边推进宽度 = 70;


static std::stack<C_Widget*> g_间隔填充部件;
static bool 当前开启文本编辑 = false;
static vec2 g节点鼠标局部位置;

static C_Widget*		g属性右键菜单 = nullptr;
static S_鼠标键位映射*	g属性右键菜单快捷键 = nullptr;


static std::set<C_属性栏视口*> g_当前所有属性栏;

static S_组件池集合	g_组件池;

Inline static C_Widget* f_间隔空部件() {
	C_Widget* w;
	if (g_间隔填充部件.size()) {
		w = g_间隔填充部件.top();
	}
	else {
		w = f_ui_创建组件();
		w->m_是否延展 = { true, true };
	}
	return w;
}

static void on_路径编辑框绘制调整回调(C_Widget* r, uint32 调整部分) {

}


S_组件池_::S_组件池_() {
}

C_Widget* S_组件池_::f_get(S_UI渲染环境* ctx, E_值类型 类型) {
	C_Widget* w = nullptr;

	auto& 集 = m_组件集[类型];

	if (集.size()) {
		w = *集.begin();
		集.erase(w);
	}
	else {
		switch (类型) {
			case e_Type_None:
				w = f_间隔空部件();
				break;
			
			case E_值类型::e_Type_ObjectOps:
			case e_Type_Operator:
				w = f_ui_创建按钮(ctx);
				break;
			
			case e_Type_UI8_FlagBits:
				break;
			case e_Type_UI16_FlagBits:
				break;
			case E_值类型::e_Type_UI32_FlagBits: 
			case E_值类型::e_Type_Bool_1D: {
				w = f_ui_创建多选框(*ctx);
				break;
			}
			
			case E_值类型::e_Type_UI32位域枚举:
			case E_值类型::e_Type_UI32Ops:
			case E_值类型::e_Type_Enum: {
				w = f_ui_创建枚举选择框(*ctx);
				break;
			}

			case e_Type_UI64_FlagBits:
				break;
			case e_Type_UI128_FlagBits:
				break;
			case e_Type_Str:
				w = f_ui_创建标签(*ctx);
				break;
			case e_Type_Bool:
				w = f_ui_创建bool值编辑框(*ctx);
				break;
			case e_Type_LineText:
				w = f_ui_创建行文本编辑框(*ctx);
				break;

			case E_值类型::e_Type_I8:
			case E_值类型::e_Type_UI8:
			case E_值类型::e_Type_I32:
			case E_值类型::e_Type_UI32:
			case E_值类型::e_Type_F32:
			case E_值类型::e_Type_F16: 
			case E_值类型::e_Type_F64: 
			case E_值类型::e_Type_F128:
			case E_值类型::e_Type_UI64: w = f_ui_创建数值编辑框(*ctx); break;

			case E_值类型::e_Type_iVec2:
			case E_值类型::e_Type_iVec3:
			case E_值类型::e_Type_uVec3:
			case E_值类型::e_Type_iVec4:
			case E_值类型::e_Type_uVec4:
			case E_值类型::e_Type_Vec2:
			case E_值类型::e_Type_Vec3:
			case E_值类型::e_Type_Vec4:
			case E_值类型::e_Type_uVec2: w = f_ui_创建vec编辑框(*ctx); break;


			case e_Type_I16:
				break;
			case e_Type_I64:
				break;
			case e_Type_I128:
				break;
			case e_Type_UI4:
				break;
			
			case e_Type_UI16:
				break;
			case e_Type_UI128:
				break;
			case e_Type_RGBA8:
				break;
			case e_Type_RGBA16:
				break;
			case e_Type_RGBA32:
				break;
			case e_Type_Quat:
				break;
			case e_Type_Str_1D:
				break;
			case e_Type_Bool_Array1D:
				break;
			case e_Type_F32_Array1D:
				break;
			case e_Type_F32_1D:
				break;
			case e_Type_F32_Range:
				break;
			case e_Type_F64_1D:
				break;
			case e_Type_I8_1D:
				break;
			case e_Type_I32_1D:
				break;
			case e_Type_I64_Array1D:
				break;
			case e_Type_UI8_Array1D:
				break;
			case e_Type_UI32_1D:
				break;
			case e_Type_Vec2_Array1D:
				break;
			case e_Type_Vec3_Array1D:
				break;
			case e_Type_Vec4_Array1D:
				break;
			case e_Type_Quat_Array1D:
				break;
			case e_Type_Vec3_1D:
				break;
			case e_Type_Vec4_1D:
				break;
			case e_Type_Index_F32_1D:
				break;
			case e_Type_Index_Vec3_1D:
				break;
			case e_Type_Mat2X2:
				break;
			case e_Type_Mat3X3:
				break;
			case e_Type_Mat4X4:
				break;
			case e_Type_2D曲线采样:
				break;
			case e_Type_2D曲线采样1D:
				break;
			case e_Type_2D曲线:
				break;
			case e_Type_2D曲线1D:
				break;
			case e_Type_Mesh:
				break;
			case e_Type_Object:
				break;
			case e_Type_Object_1D:
				break;
			case e_Type_ObjectData:
				break;
			case e_Type_ParticleSystem:
				break;
			case e_Type_Scene:
				break;
			case e_Type_集合:
				break;
			case e_Type_体素:
				break;
			case e_Type_多边形:
				break;
			case e_Type_多边形_1D:
				break;
			case e_Type_多边形边:
				break;
			case e_Type_多边形边1D:
				break;
			case e_Type_多边形面:
				break;
			case e_Type_多边形面1D:
				break;
			case e_Type_多边形元素:
				break;
			case e_Type_多边形元素1D:
				break;
			case e_Type_面顶点索引:
				break;
			case e_Type_RGB:
				break;
			case e_Type_RGBA:
				break;
			case e_Type_材质:
				break;
			case e_Type_材质1D:
				break;
			case e_Type_图像:
				break;
			case e_Type_纹理:
				break;
			case e_Type_纹理_1D:
				break;
			case e_Type_GPU缓存1D:
				break;
			case e_Type_车轮:
				break;
			case e_Type_车辆:
				break;
			case e_Type_发射:
				break;
			case e_插座Type_物理材质:
				break;
			case e_插座Type_物理几何:
				break;
			case e_插座Type_物理体:
				break;
			case e_插座Type_物理平面:
				break;
			case e_插座Type_bl物体朝向:
				break;
			case e_插座Type_引用数据:
				break;
			case e_插座Type_调试信息:
				break;
			case e_插座Type_动态转换:
				break;
			case e_插座Type_ArrayBegin:
				break;
			case e_插座Type_Str_2D:
				break;
			case e_插座Type_Str_3D:
				break;
			case e_插座Type_Str_4D:
				break;
			case e_插座Type_Array2D_Bool:
				break;
			case e_插座Type_Array3D_Bool:
				break;
			
			case e_插座Type_I8_Array2D:
				break;
			case e_插座Type_I8_Array4D:
				break;
			case e_插座Type_Vec2_Array2D:
				break;
			case e_插座Type_Vec2_Array3D:
				break;
			case e_Type_Vec2_1D:
				break;
			case e_Type_iVec2_1D:
				break;
			case e_Type_iVec3_1D:
				break;
			case e_Type_uVec2_1D:
				break;
			case e_Type_uVec3_1D:
				break;
			case e_插座Type_Vec3_Array4D:
				break;
			case e_Type_UI32_2D:
				break;
			case e_插座Type_uVec3_Array2D:
				break;
			case e_插座Type_uVec3_Array3D:
				break;
			case e_插座Type_uVec3_Array4D:
				break;
			case e_插座Type_Vec4_Array2D:
				break;
			case e_插座Type_Vec4_Array3D:
				break;
			case e_插座Type_Vec4_Array4D:
				break;
			case e_插座Type_Vec2i_Array2D:
				break;
			case e_过程纹理:
				break;
			case e_过程纹理_1D:
				break;
			case e_插座Type_Vec3i_Array1D:
				break;
			case e_插座Type_Vec3i_Array2D:
				break;
			case e_插座Type_Vec3i_Array3D:
				break;
			case e_Type_Shader:
				break;
			case e_Type_Array:
				break;
			case e_Type_Array1D:
				break;
			case e_Type_Array元素:
				break;
			case e_Type_TexProp:
				break;
			case e_插座Type_Rect32f:
				break;
			case e_插座Type_Rect32f_Array1D:
				break;
			case e_Type_Cube_Array1D:
				break;
			case e_插座Type_Vec球:
				break;
			case e_Type_VecSphere_1D:
				break;
			case e_Type_Bounding:
				break;
			case e_Type_Bounding_Array1D:
				break;
			case e_插座Type_Line:
				break;
			case e_插座Type_Line_Array1D:
				break;
			case e_Type_VN:
				break;
			case e_Type_VN_Array1D:
				break;
			case e_插座Type_Mat2X2_Array1D:
				break;
			case e_插座Type_Mat3X3_Array1D:
				break;
			case e_Type_Mat4X4_Array1D:
				break;
			case e_Type_Mat4X4_1D:
				break;
			case e_插座Type_Mat4X4_Array3D:
				break;
			case e_插座Type_Mat4X4_Array4D:
				break;
			case e_插座Type_MapiVec3_Uint32_Array1D:
				break;
			case e_插座Type_MapiVec3_Uint32_Array2D:
				break;
			case e_插座Type_Uint64Map_Uint32_Array2D:
				break;
			case e_Type_Tranform_Array1D:
				break;
			case e_Type_Mesh_1D:
				break;
			case e_插座Type_Mesh_Array2D:
				break;
			case e_Type_元素选择:
				break;
			case e_Type_元素选择1D:
				break;
			case e_插座Type_根对象_1D:
				break;
			case e_插座Type_ObjectData_Array1D:
				break;
			case e_Type_骨架:
				break;
			case e_Type_骨架_Array1D:
				break;
			case e_Type_骨骼:
				break;
			case e_Type_骨骼_Array1D:
				break;
			case e_Type_IK:
				break;
			case e_Type_IK_Array1D:
				break;
			case e_Type_Object_Array1D:
				break;
			case e_插座Type_F32_Array2D:
				break;
			case e_插座Type_F32_Array3D:
				break;
			case e_插座Type_Array4D_F32:
				break;
			case e_插座Type_I32_Array2D:
				break;
			case e_插座Type_I32_Array3D:
				break;
			case e_插座Type_I32_Array4D:
				break;
			case e_插座Type_UI32_Array2D:
				break;
			case e_插座Type_UI32_Array3D:
				break;
			case e_插座Type_UI32_Array4D:
				break;
			case e_插座Type_I64_Array2D:
				break;
			case e_插座Type_I64_Array3D:
				break;
			case e_插座Type_I64_Array4D:
				break;
			case e_插座Type_UI64_Array1D:
				break;
			case e_插座Type_VectorParticle:
				break;
			case e_插座Type_VectorScene:
				break;
			case e_插座Type_字体_1D:
				break;
			case e_插座Type_物理解算器:
				break;
			case e_插座Type_车轮_Array1D:
				break;
			case e_插座Type_车辆_Array1D:
				break;
			case e_插座Type_物理材质_Array1D:
				break;
			case e_插座Type_物理几何_Array1D:
				break;
			case e_插座Type_物理体_Array1D:
				break;
			case e_插座Type_物理平面_Array1D:
				break;
			case e_插座Type_材质_Array1D:
				break;
			case e_插座Type_通用取:
				break;
			case e_插座Type_八叉树:
				break;
			case e_插座Type_树路径:
				break;
			case e_Type_Mesh_点:
				break;
			case e_Type_Mesh_线:
				break;
			case e_Type_Mesh_面中心:
				break;
			case e_Type_Mesh_点1D:
				break;
			case e_Type_Mesh_线1D:
				break;
			case e_Type_Mesh_面中心1D:
				break;
			case e_Type_Node:
				break;
			case e_Type_Widget:
				break;
			case e_Type_路径:
				w = f_ui_创建路径编辑框(*ctx, S_框架::g_ui文件对话框, on_路径编辑框绘制调整回调);
				break;
			case e_Type_MapPtr:
				break;
			case e_Type_MapPtr_Array1D: w = f_ui_创建下拉列表(*ctx, true); break;
			case e_Type_PropContainer:
				break;
			case e_Type_PropList:
				break;
			case e_Type_LayoutBegin:
				break;
			case e_Type_LayoutList:
				break;
			case e_Type_LayoutMesh:
				break;
			case e_Type_LayoutTypeEdit:
				break;
			case e_Type_LayoutEnd:
				break;
			case e_Type_I32_2D:
				break;
			case e_Type_Vec3_2D:
				break;
			case e_Type_iVec4_1D:
				break;
			case e_Type_iVec3_2D:
				break;
			case e_Type_Bounding_1D:
				break;
			case e_Type_i8体素:
				break;
			case e_Type_映射引用_2D: w = f_ui_创建超级列表编辑框(*ctx, true); break;
			case e_Type_键位映射:
				break;
			case e_Type_字体:
				break;
			case e_Type_网格自定义属性:
				break;
			case e_Type_UI8位域枚举:
				w = f_ui_创建多选框(*ctx);
				break;
			case e_Type_UI16位域枚举:
				break;
			
			case e_Type_UI64位域枚举:
				break;
			case e_Type_UI128位域枚举:
				break;
			
			case e_Type_ArrayRef:
				break;
			case e_Type_LineStr1D:
				break;
			case e_Type_LigthParallel:
				break;
			case e_Type_LigthPoint:
				break;
			case e_Type_LigthArea:
				break;
			case e_Type_LigthSpot:
				break;
			case e_Type_SocketContainer:
				break;
			case e_Type_ContainerBool:
				break;
			case e_Type_ContainerF32:
				break;
			case e_Type_ContainerI8:
				break;
			case e_Type_ContainerI32:
				break;
			case e_Type_ContainerUI32:
				break;
			case e_Type_ContainerVec2:
				break;
			case e_Type_ContainerVec3:
				break;
			case e_Type_ContainerVec4:
				break;
			case e_Type_ContaineriVec2:
				break;
			case e_Type_ContaineriVec3:
				break;
			case e_Type_ContaineriVec4:
				break;
			case e_Type_ContainerBound:
				break;
			case e_Type_ContainerValue:
				break;
			case e_Type_网格元素索引:
				break;
			case e_Type_颜色:
				break;
			case e_Type_Curve3D:
				break;
			case E_值类型::e_Type_TexSets:
				w = f_ui_创建图像集视口(*ctx);
				break;
			case E_值类型::e_Type_ObjectContainerMap:
			case E_值类型::e_Type_ObjectContainerArray:
				w = f_ui_创建弹出列表编辑框(*ctx, f_NODE_创建物体节点, true);
				break;
			case e_Type_End:
				break;
			default:
				break;
		}

		if (w) {
			w->m_Type = 类型;
		}
	}
	return w;
}


S_组件池集合::S_组件池集合() {
	
}


C_Widget* S_组件池集合::f_get(S_UI渲染环境* ctx, S_Props& prop) {
	C_Widget* w = m_不同设备组件池[ctx->m_Ctx.m_全局设备ID].f_get(ctx, prop.m_Type);
	w->f_bind属性(prop);
	return w;
}

void S_组件池集合::f_归还组件(uint32 全局设备ID, uint32 num, C_Widget** ws) {
	
	auto& e = m_不同设备组件池[全局设备ID];
	for (uint32 i = 0; i < num; ++i) {
		auto& 集 = e.m_组件集[E_值类型(ws[i]->m_Type)];
		集.insert(ws[i]);
	}
	
}



static C_StrKey分配器 g渲染物体键值;
//static auto f_名称构建 = [](C_Widget* self, S_MapObject& item) -> std::u16string {
//	
//	std::u16string name = u"物体节点";
//	if (item.当前选项.empty()) {
//		name = g渲染物体键值.f_Gen(name);
//	}
//	else {
//		if (item.容器->find(item.当前选项) != item.容器->end()) {
//			name = g渲染物体键值.f_Gen(u"物体节点");
//		}
//	}
//	return name;
//};

void f_NODE_创建物体节点(S_UI渲染环境& ctx, C_Widget* self) {
	if (S_框架::g_拾取物体.size()) {
		auto& item = *f_prop_ObjectMap(self->m_自定义属性);
		//auto name = f_名称构建(self, item);
		std::u16string name = u"物体节点";
		if (item.当前项.当前选项.empty()) {
			name = g渲染物体键值.f_Gen(name);
		}
		else {
			if (item.容器->find(item.当前项.当前选项) != item.容器->end()) {
				name = g渲染物体键值.f_Gen(u"物体节点");
			}
		}

		item.当前项.当前选项 = name; 
		item.当前项.当前对象 = new C_节点容器(name, false);
		(*item.容器)[name] = item.当前项.当前对象;
		(*S_框架::g_拾取物体.begin())->m_扩展属性[0] = item.当前项.当前对象;

		f_工作区_联动更新(E_工作区类型::e_属性面板, E_工作区操作类型::e_创建物体节点);
	}
}

void f_NODE_创建场景节点(S_UI渲染环境& ctx, C_Widget* self) {
	auto& item = *f_prop_ObjectArray(self->m_自定义属性);
	auto& 容器 = (*item.容器);

	std::u16string name = u"场景节点";
	if (item.当前项.当前选项.empty()) {
		name = g渲染物体键值.f_Gen(name);
	}
	else {
		auto it = std::find_if(容器.begin(), 容器.end(), [&name](const S_Object* ob){
			return ob->m_Name == name;
		});
		if (it != item.容器->end()) {
			name = g渲染物体键值.f_Gen(u"场景节点");
		}
	}

	item.当前项.当前选项 = name; 
	item.当前项.当前对象 = new C_节点容器(name, false);
	容器.push_back(item.当前项.当前对象);

	f_工作区_联动更新(E_工作区类型::e_属性面板, E_工作区操作类型::e_创建场景节点);
}

void f_NODE_物体节点名称修改(S_Props& prop) {
	auto& item = *f_prop_ObjectMap(prop);
	auto& 容器 = (*item.容器);

	if (item.当前项.当前对象) {
		if (S_框架::g_拾取物体.size() && 容器.find(item.当前项.当前选项) != 容器.end()) {
			item.当前项.当前对象 = 容器[item.当前项.当前选项];
			(*S_框架::g_拾取物体.begin())->m_扩展属性[0] = item.当前项.当前对象;

			f_工作区_联动更新(E_工作区类型::e_属性面板, E_工作区操作类型::e_切换物体节点);
			return;
		}
	}
	if(item.当前项.当前对象 == nullptr || item.当前项.当前对象->m_Name == item.当前项.当前选项) return;

	
	item.当前项.当前选项 = g渲染物体键值.f_Gen(item.当前项.当前选项);
	
	if (容器.find(item.当前项.当前对象->m_Name) != 容器.end()) {
		容器.erase(item.当前项.当前对象->m_Name);
	}

	item.当前项.当前对象->m_Name = item.当前项.当前选项;
	容器[item.当前项.当前选项] = item.当前项.当前对象;

	//f_widget_更新渲染层(prop.m_UI->m_部件);
	f_工作区_联动更新(E_工作区类型::e_属性面板, E_工作区操作类型::e_修改节点名称);
}

void f_NODE_场景节点名称修改(S_Props& prop) {
	auto& item = *f_prop_ObjectArray(prop);
	auto& 容器 = (*item.容器);

	if (item.当前项.当前对象) {
		auto it = std::find_if(容器.begin(), 容器.end(), [&item](const S_Object* ob){ 
			return ob->m_Name == item.当前项.当前选项; 
		});

		if (S_框架::g_拾取物体.size() && it != 容器.end()) {
			item.当前项.当前对象 = *it;
			(*S_框架::g_拾取物体.begin())->m_扩展属性[0] = item.当前项.当前对象;

			f_工作区_联动更新(E_工作区类型::e_属性面板, E_工作区操作类型::e_切换场景节点);
			return;
		}
	}
	if(item.当前项.当前对象 == nullptr || item.当前项.当前对象->m_Name == item.当前项.当前选项) return;


	item.当前项.当前选项 = g渲染物体键值.f_Gen(item.当前项.当前选项);
	item.当前项.当前对象->m_Name = item.当前项.当前选项;
	
	f_工作区_联动更新(E_工作区类型::e_属性面板, E_工作区操作类型::e_修改节点名称);
}



static bool on_属性右键菜单项事件(C_Widget* self, const std::u16string name, uint16 id) {
	if (name == u"插入关键帧") {
		
	}
	else if (name == u"插入单项关键帧") {

	}
	else if (name == u"删除关键帧") {

	}
	else if (name == u"删除单项关键帧") {
		
	}
	return false;
}

E_事件是否传递 on_打开属性右键菜单事件(C_Widget* self, E_键位执行状态 状态) {
	f_ui_打开弹出窗口(g属性右键菜单, C_Widget::g_鼠标.gPos);
	return E_事件是否传递::e_事件传递_终止;
}



static void f_节点PropUpdate(S_Props& prop) {

}

static bool g是否有手柄在拖动 = false;
//static E_事件是否传递 on_手柄鼠标进入(C_Widget* self, const S_鼠标& 轮值) {
//	C_Widget::g_鼠标样式 = E_鼠标样式::e_鼠标样式_横向双箭头;
//	self->m_拖放阻止鼠标进出事件 = true;
//	self->m_父部件->m_父部件->m_更新绘制属性 = true;
//	return E_事件是否传递::e_事件传递_继续;
//}
//
//static E_事件是否传递 on_手柄鼠标移出(C_Widget* self, const S_鼠标& 轮值) {
//	if (!g是否有手柄在拖动) {
//		C_Widget::g_鼠标样式 = E_鼠标样式::e_鼠标样式_默认;
//	}
//	if (!self->m_拖放阻止鼠标进出事件) {
//		self->m_ColorA.m_颜色.a = S_UI主题::uic_拖拽手柄.a;
//		self->m_更新绘制属性 = true;
//		self->m_父部件->m_父部件->m_更新绘制属性 = true;
//	}
//	return E_事件是否传递::e_事件传递_继续;
//}

static E_事件是否传递 on_手柄准备拖动(C_Widget* self, const S_鼠标& 鼠标, S_拖放数据& data) {
	C_属性栏* 属性栏 = static_cast<C_属性栏*>(self);
	属性栏->m_View->m_手柄;
	g节点鼠标局部位置 = f_widget_get鼠标局部位置(C_Widget::g_鼠标.gPos, self);
	g是否有手柄在拖动 = true;

	data.m_Type = E_拖放数据类型::e_鼠标拖放_分割条;
	data.m_Next = self;

	self->m_拖放阻止鼠标进出事件 = true;
	C_Widget::g_鼠标样式 = E_鼠标样式::e_鼠标样式_横向双箭头;
	return E_事件是否传递::e_事件传递_继续;
}

static E_事件是否传递 on_手柄拖动(C_Widget* self, const S_鼠标& 鼠标, S_拖放数据& data) {
	if(data.m_Type != E_拖放数据类型::e_鼠标拖放_分割条 || data.m_Next != self) return E_事件是否传递::e_事件传递_继续;
	C_属性栏* 属性栏 = static_cast<C_属性栏*>(self);
	
	vec2 pos = f_widget_get鼠标局部位置(C_Widget::g_鼠标.gPos, self->m_父部件);
	pos.x -= g节点鼠标局部位置.x;
	pos.y = 0;

	if (pos.x < 10) pos.x = 10;
	self->f_setPos(pos);
	self->m_父部件->f_setW(pos.x + S_UI主题::ui_拖拽手柄宽度);
	self->m_父部件->m_父部件->m_更新绘制属性 = true;
	
	return E_事件是否传递::e_事件传递_继续;
}


static bool on_手柄结束拖动(C_Widget* self, C_Widget* 拾取的部件, S_拖放数据& data) {
	C_属性栏* 属性栏 = static_cast<C_属性栏*>(self);
	g是否有手柄在拖动 = false;

	self->m_ColorA.m_颜色.a = S_UI主题::uic_拖拽手柄.a;
	self->m_拖放阻止鼠标进出事件 = false;
	C_Widget::g_鼠标样式 = E_鼠标样式::e_鼠标样式_默认;
	return true;
}







static void on_节点树映射_下拉列表变换修改(C_Widget* self) {
	ui_绘制模板_预设图形& 背景绘制 = *static_cast<ui_绘制模板_预设图形*>(self->m_绘图模板[0]);
	ui_绘制模板_图标& 图标绘制 = *static_cast<ui_绘制模板_图标*>(self->m_绘图模板[1]);


	S_2D_PanelAttr 属性;
	属性.m_Scale = { 1,1 };
	属性.m_Offset = {};
	属性.m_间隔 = S_UI主题::ui_文字间隔;
	属性.m_渐变数量 = 0;
	f_vg_set属性(self->m_画布, 背景绘制.m_属性, 属性);



	背景绘制.f_alloc(4);
	mat3X2 mat;

	mat.row0 = {};
	mat.row1 = self->m_Size;
	mat.row2 = { S_UI主题::ui_面板圆角半径, 0 };
	背景绘制.f_set单色填充(0, mat, S_UI主题::uic_浅灰, S_Widget预设凸包图元::m_圆角矩形);


	auto e = self->f_get更新组件();
	mat.row0 = e.m_W[0]->m_Pos;
	mat.row1 = e.m_W[0]->m_Size;
	mat.row2 = { S_UI主题::ui_面板圆角半径, 0 };
	背景绘制.f_set单色填充(1, mat, e.m_W[0]->m_颜色A, S_Widget预设凸包图元::m_左圆角矩形);

	mat.row0 = e.m_W[2]->m_Pos;
	mat.row1 = e.m_W[2]->m_Size;
	mat.row2 = { S_UI主题::ui_面板圆角半径, 0 };
	背景绘制.f_set单色填充(2, mat, e.m_W[2]->m_颜色A, S_Widget预设凸包图元::m_矩形);

	mat.row0 = e.m_W[3]->m_Pos;
	mat.row1 = e.m_W[3]->m_Size;
	mat.row2 = { S_UI主题::ui_面板圆角半径, 0 };
	背景绘制.f_set单色填充(3, mat, e.m_W[3]->m_颜色A, S_Widget预设凸包图元::m_右圆角矩形);




	//图标绘制.f_alloc(3);
	//mat.row0 = e.m_W[0]->m_Pos + e.m_W[0]->m_Size * 0.5;
	//mat.row1.x = mat.row1.y = e.m_W[0]->m_Size.y * 0.8f;
	//mat.row2 = {};
	//图标绘制.f_set("import", 0, mat, S_UI主题::uic_深白);
	//
	//mat.row0 = e.m_W[2]->m_Pos + e.m_W[2]->m_Size * 0.5;
	//mat.row1.x = mat.row1.y = e.m_W[2]->m_Size.y * 0.8f;
	//mat.row2 = {};
	//图标绘制.f_set("新建文件", 1, mat, S_UI主题::uic_深白);
	//
	//mat.row0 = e.m_W[3]->m_Pos + e.m_W[3]->m_Size * 0.5;
	//mat.row1.x = mat.row1.y = e.m_W[3]->m_Size.y * 0.8f;
	//mat.row2 = {};
	//图标绘制.f_set(e.m_W[3]->m_ICO, 2, mat, S_UI主题::uic_深白);

}




/*
	枚举部件函数回调区
*/

static void on_枚举项部件更新(C_Widget* 枚举项部件, uint8 e) {
	C_属性栏视口* 属性面板 = dynamic_cast<C_属性栏视口*>(枚举项部件->m_父部件);
}

static bool f_vec部件开启编辑(C_Widget* self, const E_鼠标按钮& 按钮) {
	C_属性栏视口* 属性面板 = dynamic_cast<C_属性栏视口*>(self->m_父部件->m_父部件);
	return true;
}

static void on_vec编辑框当前输入(C_Widget* self, std::wstring& text) {
	C_属性栏视口* 属性面板 = dynamic_cast<C_属性栏视口*>(self->m_父部件->m_父部件);
}

static void f_vec3_行编辑框变换修改(C_Widget* self, mat3X2** t, uint16 num) {
	C_属性栏视口* 属性面板 = dynamic_cast<C_属性栏视口*>(self->m_父部件->m_父部件);
	C_文本框* editBox = dynamic_cast<C_文本框*>(self);
	
}






C_工具视口部件容器::C_工具视口部件容器() : m_准备废弃_组件内文本(20), m_名称标签(20) {
	m_分组框使用计数 = 0;
	m_标签使用计数 = 0;
	m_按钮使用计数 = 0;
	m_开关使用计数 = 0;
	m_vec2使用计数 = 0;
	m_vecf使用计数 = 0;
	m_vec4使用计数 = 0;
	m_插座列表框使用计数 = 0;
	m_拾色器使用计数 = 0;
	m_曲线采样器使用计数 = 0;

	m_vec全部分量使用计数 = 0;
}



C_属性栏视口::C_属性栏视口(S_UI渲染环境& ctx) : C_Widget(&ctx) {
	f_setSize({128, 20});
	
	//mf_外部部件更新 = 0;
	//m_外部绑定部件 = 0;
	m_滚动量 = 0;

	m_布局方向 = E_方向::e_纵向;

	g_当前所有属性栏.insert(this);
}

C_属性栏视口::~C_属性栏视口() {
	g_当前所有属性栏.erase(this);

	for (auto& e : m_属性) {
		//if (!e.m_私有) f_prop_Release(e);
	}
	m_属性.clear();
}


void C_属性栏视口::f_打开() {
	g_当前所有属性栏;
}

void C_属性栏视口::f_关闭() {
	g_当前所有属性栏;
}


void C_属性栏视口::f_重新构建组件(std::vector<S_Props>& newProp) {
	uint32 i = 0;

	for (auto& e : newProp) {
		C_Widget* w = g_组件池.f_get(m_UIctx, e);

		switch (e.m_Type) {
			case E_值类型::e_Type_Str: {
				++m_标签使用计数;
				break;
			}

			case E_值类型::e_Type_LineText: {
				++m_标签使用计数;
				break;
			}

			case E_值类型::e_Type_路径: {
				++m_标签使用计数;
				break;
			}

			
			case E_值类型::e_Type_ObjectOps: 
			case E_值类型::e_Type_Operator: {
				//f_ui_bind按钮操作符(w, e);
				break;
			}

			case E_值类型::e_Type_UI32位域枚举:
			case E_值类型::e_Type_UI32Ops:
			case E_值类型::e_Type_Enum: {
				//f_ui_bind枚举部件属性(w, e);
				++m_标签使用计数;
				break;
			}

			case E_值类型::e_Type_Bool:
				++m_标签使用计数;
				break;


			case E_值类型::e_Type_I8:
			case E_值类型::e_Type_UI8:
			case E_值类型::e_Type_I32:
			case E_值类型::e_Type_UI32:
			case E_值类型::e_Type_F32:
			case E_值类型::e_Type_UI64:
				f_ui_注册鼠标快捷键(w, (S_键位映射*)g属性右键菜单快捷键);
				++m_标签使用计数;
				break;

			case E_值类型::e_Type_iVec2:
			case E_值类型::e_Type_Vec2:
			case E_值类型::e_Type_uVec2:
			case E_值类型::e_Type_iVec3:
			case E_值类型::e_Type_uVec3:
			case E_值类型::e_Type_Vec3:
			case E_值类型::e_Type_Vec4:
				f_ui_setVec布局方向(w, m_布局方向);
				break;


			//case E_值类型::e_Type_UI32_FlagBits: 
			//case E_值类型::e_Type_Bool_1D: {
			//	if (m_多选框_部件.size() > m_多选框使用计数) {
			//		w = m_多选框_部件[m_多选框使用计数];
			//	}
			//	else {
			//		w = f_ui_创建多选框(*m_UIctx);
			//	}
			//	f_ui_bind多选框属性(w, e, m_布局方向);
			//	++m_多选框使用计数;
			//	++m_标签使用计数;
			//	break;
			//}

			case E_值类型::e_Type_MapPtr_Array1D: {
				break;
				if (m_列表框_部件.size() > m_列表框使用计数) {
					w = m_列表框_部件[m_列表框使用计数];
				}
				else {
					w = f_ui_创建下拉列表(*m_UIctx, true, !m_布局方向);
				}
				w->mf_变换 = on_节点树映射_下拉列表变换修改;
				f_ui_绑定下拉列表属性(w, e);

				++m_列表框使用计数;
				
			}
			case E_值类型::e_Type_映射引用_2D: {
				//if (m_超级列表编辑框_组件.size() > m_超级列表编辑框计数) {
				//	w = m_超级列表编辑框_组件[m_超级列表编辑框计数];
				//}
				//else {
				//	w = f_ui_创建超级列表编辑框(*m_UIctx, true);
				//}
				//f_ui_绑定超级列表编辑框属性(w, e);
				//
				//++m_超级列表编辑框计数;
				break;
			}

			case E_值类型::e_Type_Object_1D:
			case E_值类型::e_Type_SocketContainer:
				if (m_插座列表框_部件.size() > m_插座列表框使用计数) {
					w = m_插座列表框_部件[m_插座列表框使用计数];
				} else {
					w = f_创建插座编辑列表(*m_UIctx);
					m_插座列表框_部件.emplace_back(w);
				}
				//e.m_UI->m_部件 = w;
				f_插座编辑列表绑定属性数据(w, e, E_编辑列表类型::e_插座列表);
				++m_插座列表框使用计数;
				break;

			case E_值类型::e_Type_PropContainer:
			case E_值类型::e_Type_ContainerBool:
			case E_值类型::e_Type_ContainerF32:
			case E_值类型::e_Type_ContainerI8:
			case E_值类型::e_Type_ContainerI32:
			case E_值类型::e_Type_ContainerUI32: {
				if (m_插座列表框_部件.size() > m_插座列表框使用计数) {
					w = m_插座列表框_部件[m_插座列表框使用计数];
				}
				else {
					w = f_创建插座编辑列表(*m_UIctx);
					m_插座列表框_部件.emplace_back(w);
				}
				f_插座编辑列表绑定属性数据(w, e, E_编辑列表类型::e_标量列表);
				++m_插座列表框使用计数;
				break;
			}
			case E_值类型::e_Type_ContainerVec2:
			case E_值类型::e_Type_ContainerVec3:
			case E_值类型::e_Type_ContainerVec4:
			case E_值类型::e_Type_ContaineriVec2:
			case E_值类型::e_Type_ContaineriVec3:
			case E_值类型::e_Type_ContaineriVec4:
			case E_值类型::e_Type_ContainerBound:
			case E_值类型::e_Type_ContainerValue: {
				if (m_插座列表框_部件.size() > m_插座列表框使用计数) {
					w = m_插座列表框_部件[m_插座列表框使用计数];
				}
				else {
					w = f_创建插座编辑列表(*m_UIctx);
					m_插座列表框_部件.emplace_back(w);
				}
				f_插座编辑列表绑定属性数据(w, e, E_编辑列表类型::e_矢量列表);
				++m_插座列表框使用计数;
				break;
			}

			case E_值类型::e_Type_RGB:
			case E_值类型::e_Type_RGBA:
			case E_值类型::e_Type_纹理:
				if (m_拾色器_部件.size() > m_拾色器使用计数) {
					w = m_拾色器_部件[m_拾色器使用计数];
				}
				else {
					w = f_ui_创建拾色器(*m_UIctx, e);
					m_拾色器_部件.push_back(w);
				}
				f_ui_拾色器绑定属性(w, e);
				++m_拾色器使用计数;
				//++m_标签使用计数;
				break;

			case E_值类型::e_Type_TexProp:
				if (m_纹理_部件.size() > m_纹理使用计数) {
					w = m_纹理_部件[m_纹理使用计数];
				}
				else {
					w = f_ui_创建过程纹理图像框(*m_UIctx);
					m_纹理_部件.push_back(w);
				}
				f_ui_bind图像框纹理属性(w, e);
				++m_纹理使用计数;
				//++m_标签使用计数;
				break;

			case E_值类型::e_Type_2D曲线: {
				if (m_曲线采样器_部件.size() > m_曲线采样器使用计数) {
					w = m_曲线采样器_部件[m_曲线采样器使用计数];
				}
				else {
					w = f_ui_创建曲线采样器(*m_UIctx);
					m_曲线采样器_部件.push_back(w);
				}
				f_ui_曲线采样器绑定属性数据(w, e);
				++m_曲线采样器使用计数;
				break;
			}

			case E_值类型::e_Type_Node: {
				break;
			}

			case E_值类型::e_Type_LayoutList: {
				if (m_分组框.size() > m_分组框使用计数) {
					w = m_分组框[m_分组框使用计数];
				}
				else {
					w = f_ui_创建组件();
					m_分组框.push_back(w);
				}

				w->m_实例ID = m_分组框使用计数;
				++m_分组框使用计数;
			
				w->m_TypeName = f_str_u16_to_u8(e.m_Name);
				//e.m_UI->m_部件 = w;
				e.m_UI->m_部件 = w;
				++i;
				f_添加子组件(w);

				auto& container = f_prop_Container(e);
				f_重新构建组件(container.m_Item);
				continue;
			}

			case E_值类型::e_Type_UI8位域枚举: {
				f_ui_bind多选框属性(w, e, m_布局方向);
				++m_标签使用计数;
				break;
			}

			case E_值类型::e_Type_ObjectContainerArray:
			case E_值类型::e_Type_ObjectContainerMap: {
				if (e.m_Name == u"物体节点") {
					w->m_子组件[0]->m_ICO = u"加";
					f_ui_弹出列表编辑框绑定数据(w, e, f_NODE_创建物体节点);
				}
				else if (e.m_Name == u"场景节点") {
					w->m_子组件[0]->m_ICO = u"加";
					f_ui_弹出列表编辑框绑定数据(w, e, f_NODE_创建场景节点);
				}
				else {
					w->m_子组件[0]->m_ICO = u"加";
					f_ui_弹出列表编辑框绑定数据(w, e, nullptr);
				}
				//auto ob = f_prop_Object(e);
				//if (ob) {
				//	switch (ob->m_Type) {
				//		case E_物体类型::t_网格物体: {
				//			f_ui_弹出列表编辑框绑定数据(w, e, nullptr);
				//			break;
				//		}
				//		case E_物体类型::t_物体节点 : {
				//			w->m_子组件[0]->m_ICO = u"加";
				//			f_ui_弹出列表编辑框绑定数据(w, e, f_NODE_创建物体节点);
				//			break;
				//		}
				//		case E_物体类型::t_场景节点 : {
				//			w->m_子组件[0]->m_ICO = u"加";
				//			f_ui_弹出列表编辑框绑定数据(w, e, f_NODE_创建场景节点);
				//			break;
				//		}
				//		default:
				//			break;
				//	}
				//}
				//else {
				//	w->m_子组件[0]->m_ICO = u"加";
				//	f_ui_弹出列表编辑框绑定数据(w, e, nullptr);
				//}
				break;
			}

			case E_值类型::e_Type_TexSets: {
				f_ui_bind图像集视口属性(w, e);
				break;
			}

			default: {
				if (!w) {
					e.m_UI->m_部件 = nullptr;
					continue;
				}
				else {
					
				}
			}
		}

		w->m_TypeName = f_str_u16_to_u8(e.m_Name);
		e.m_UI->m_部件 = w;
		++i;

		f_添加子组件(w);
	}
}

void C_属性栏视口::f_构建属性部件(const std::vector<S_Props>& newProp) {
	g_组件池.f_归还组件(m_UIctx->m_Ctx.m_全局设备ID, m_子组件.size(), m_子组件.data());
	m_子组件.clear();


	for (auto& e : m_属性) {
		if (!e.m_私有) f_prop_Release(e);
	}
	m_属性 = newProp;

	f_重新构建组件(m_属性);

	m_更新绘制属性 = true;
}

void C_属性栏视口::f_切换方向(E_方向 方向) {
	m_布局方向 = 方向;
}





static void f_属性栏标签GPU参数修改(C_属性栏视口* box, S_Props& e, uint32& i, const S_Font& 字体) {
	if (!e.m_UI->m_部件) return;

	switch (e.m_Type) {
		case E_值类型::e_Type_Str:
		case E_值类型::e_Type_Bool:

		case E_值类型::e_Type_I8:
		case E_值类型::e_Type_UI8:
		case E_值类型::e_Type_I32:
		case E_值类型::e_Type_UI32:
		case E_值类型::e_Type_F32:
		case E_值类型::e_Type_UI64:
	
		case E_值类型::e_Type_iVec2:
		case E_值类型::e_Type_Vec2:
		case E_值类型::e_Type_uVec2:
		case E_值类型::e_Type_uVec3:
		case E_值类型::e_Type_Vec3:
		case E_值类型::e_Type_iVec3:
	
		case E_值类型::e_Type_路径:
		//case E_值类型::e_Type_TexProp:
		case E_值类型::e_Type_LineText:
		//case E_值类型::e_Type_Node:
	
		case E_值类型::e_Type_UI32Ops:
		case E_值类型::e_Type_UI32位域枚举:
		case E_值类型::e_Type_Enum:
		//case E_值类型::e_Type_纹理:
			//box->m_标签绘制.f_绘制文本({ {0, e.m_UI->m_部件->m_Pos.y + g两边间隙}, {g左边推进宽度, g_值部件大小 } }, S_UI主题::uic_文字颜色, i, e.m_Name, E_对齐方式::e_右对齐);
			//box->m_标签绘制.f_绘制文本({ {0, e.m_UI->m_部件->m_Pos.y + g两边间隙}, {g左边推进宽度, g_值部件大小 } }, S_UI主题::uic_文字颜色, i, e.m_Name, E_对齐方式::e_右对齐);
			//box->m_标签绘制.f_绘制文本({ {0, e.m_UI->m_部件->m_Pos.y + g两边间隙}, {g左边推进宽度 - g两边间隙, g_值部件大小 } }, S_UI主题::uic_文字颜色, i, L"", E_对齐方式::e_右对齐);
			++i;
			break;

		case E_值类型::e_Type_UI8位域枚举:
			//box->m_标签绘制.f_绘制文本({ {0, e.m_UI->m_部件->m_Pos.y - g_值部件大小}, {g左边推进宽度, g_值部件大小 } }, S_UI主题::uic_文字颜色, i, e.m_Name, E_对齐方式::e_左对齐);
			++i;
			break;
	}
	

	switch (e.m_Type) {
		case E_值类型::e_Type_LayoutList: {
			auto& container = f_prop_Container(e);
			for (auto& se : container.m_Item) {
				f_属性栏标签GPU参数修改(box, se, i, 字体);
			}
			break;
		}
	}
	f_widget_更新绘制(box);
}






static void on_属性栏单个组件布局(C_属性栏视口* 属性栏, vec2& pos, S_Props& e, float32 推进, float32 宽度, float32 dpi) {
	uint8 矢量部件分量数量 = 0;

	推进 += g两边间隙 * dpi;
	宽度 -= ((g两边间隙 * 2) + 10) * dpi;

	vec2 推进左边 = pos;
	if (!e.m_UI->m_部件) return;
	
	float32 组件高度 = g_值部件大小 * dpi;

	switch (e.m_Type) {
		case E_值类型::e_Type_LayoutList: {
			float32 高度 = pos.y;
			e.m_UI->m_部件->f_setPos(pos);

			pos.y += g上下间隙;
			auto& container = f_prop_Container(e);
			for (auto& se : container.m_Item) {
				on_属性栏单个组件布局(属性栏, pos, se, 推进, 宽度, dpi);
			}

			高度 = pos.y - 高度;
			e.m_UI->m_部件->f_setSize({ 宽度, 高度 });
			break;
		}

		case E_值类型::e_Type_ObjectOps:
		case E_值类型::e_Type_Operator: {
			e.m_UI->m_部件->f_setPos(推进左边);
			e.m_UI->m_部件->f_setSize({ 宽度, 组件高度 });
			break;
		}
		
		case E_值类型::e_Type_UI32位域枚举:
		case E_值类型::e_Type_UI32Ops:
		case E_值类型::e_Type_Enum: {
			S_PropValueEnum 枚举 = *((S_PropValueEnum*)e.m_Value);

			vec2 枚举部件大小 = vec2{ 宽度, 组件高度 };
			if (枚举.m_展开) {
				f_ui_set枚举选择框(e.m_UI->m_部件, E_方向::e_纵向);
			}
			else {
				f_ui_set枚举选择框(e.m_UI->m_部件, E_方向::e_纵向);
			}

			枚举部件大小.y *= e.m_值元素个数;

			e.m_UI->m_部件->f_setPos(推进左边);
			e.m_UI->m_部件->f_setSize(枚举部件大小);

			pos.y += 枚举部件大小.y;
			break;
		}

		case E_值类型::e_Type_Node:
		case E_值类型::e_Type_Str:
		case E_值类型::e_Type_LineText:
		case E_值类型::e_Type_路径: {
			e.m_UI->m_部件->f_setPos(推进左边);
			e.m_UI->m_部件->f_setSize({ 宽度, 组件高度 });
			break;
		}

		case E_值类型::e_Type_Bool: {
			e.m_UI->m_部件->f_setPos(推进左边);
			e.m_UI->m_部件->f_setSize({ 组件高度, 组件高度 });
			break;
		}
		
		case E_值类型::e_Type_I16:
		case E_值类型::e_Type_I32:
		case E_值类型::e_Type_I64:
		case E_值类型::e_Type_UI64:
		case E_值类型::e_Type_F32:
		case E_值类型::e_Type_F64: {
			e.m_UI->m_部件->f_setPos(推进左边);
			e.m_UI->m_部件->f_setSize({ 宽度, 组件高度 });
			break;
		}

		case E_值类型::e_Type_uVec2:
		case E_值类型::e_Type_iVec2:
		case E_值类型::e_Type_Vec2: {
			矢量部件分量数量 = 2;
			goto To_矢量部件布局;
			break;
		}

		case E_值类型::e_Type_iVec3:
		case E_值类型::e_Type_uVec3:
		case E_值类型::e_Type_Vec3: {
			矢量部件分量数量 = 3;
			goto To_矢量部件布局;
			break;
		}
		
		case E_值类型::e_Type_Vec4:
			矢量部件分量数量 = 4;
			goto To_矢量部件布局;
			break;

		case E_值类型::e_Type_RGB:
		case E_值类型::e_Type_RGBA:
		case E_值类型::e_Type_纹理:
			e.m_UI->m_部件->f_setPos(推进左边);
			e.m_UI->m_部件->f_setSize({ 宽度, 组件高度 });
			break;

		case E_值类型::e_Type_TexProp:
			e.m_UI->m_部件->f_setPos(pos);
			e.m_UI->m_部件->f_setSize({ 宽度, 200 });
			pos.y += 200 + S_UI主题::ui_面板圆角半径;
			return;

		case E_值类型::e_Type_2D曲线:
			e.m_UI->m_部件->f_setPos(pos);
			e.m_UI->m_部件->f_setSize({ 宽度, 160 });
			pos.y += 160 + S_UI主题::ui_面板圆角半径;
			return;

		case E_值类型::e_Type_UI32_FlagBits: {
			float32 h = e.m_UI->m_部件->f_get子部件数量() * 20;
			e.m_UI->m_部件->f_setPos(pos);
			e.m_UI->m_部件->f_setSize({ 宽度, h });
			pos.y += h + S_UI主题::ui_面板圆角半径;
			break;
		}

		case E_值类型::e_Type_UI8位域枚举: {
			pos.y += 组件高度;
			e.m_UI->m_部件->f_setPos(pos + vec2{g两边间隙 * dpi,0});
			e.m_UI->m_部件->f_setSize({ 宽度, 组件高度 });
			pos.y += 组件高度;
			break;
		}

		case E_值类型::e_Type_Bool_1D: {
			e.m_UI->m_部件->f_setPos(pos);
			e.m_UI->m_部件->f_setSize({ 宽度, e.m_值元素个数 * 20 + S_UI主题::ui_面板圆角半径 });
			pos.y += e.m_UI->m_部件->m_Size.y;
			break;
		}

		case E_值类型::e_Type_映射引用_2D:
		case E_值类型::e_Type_MapPtr_Array1D: {
			e.m_UI->m_部件->f_setPos(pos);
			e.m_UI->m_部件->f_setSize({ 宽度, 组件高度 });
			pos.y += 组件高度;
			break;
		}

		case E_值类型::e_Type_Object_1D:
		case E_值类型::e_Type_ContainerBool:
		case E_值类型::e_Type_ContainerF32:
		case E_值类型::e_Type_ContainerI8:
		case E_值类型::e_Type_ContainerI32:
		case E_值类型::e_Type_ContainerUI32:
		case E_值类型::e_Type_ContainerVec2:
		case E_值类型::e_Type_ContainerVec3:
		case E_值类型::e_Type_ContainerVec4:
		case E_值类型::e_Type_ContaineriVec2:
		case E_值类型::e_Type_ContaineriVec3:
		case E_值类型::e_Type_ContaineriVec4:
		case E_值类型::e_Type_ContainerBound:
		case E_值类型::e_Type_ContainerValue:
		case E_值类型::e_Type_SocketContainer:
		case E_值类型::e_Type_PropContainer: {
			//插座列表
			e.m_UI->m_部件->f_setPos(pos);
			e.m_UI->m_部件->f_setSize({ 宽度, 组件高度*30 });
			pos.y += 组件高度 * 30;
			break;
		}

		case E_值类型::e_Type_ObjectContainerArray:
		case E_值类型::e_Type_ObjectContainerMap: {
			e.m_UI->m_部件->f_setPos(pos);
			e.m_UI->m_部件->f_setSize({ 宽度, 组件高度 });
			break;
		}

		case E_值类型::e_Type_TexSets: {
			auto& ts = f_prop_纹理集(e);
			float32 height = 宽度;
			if (ts.m_纹理集->data->count) {
				auto tex = f_纹理集_get纹理(ts.m_纹理集, 0);
				
				if (tex) {
					switch (tex->m_类型) {
						case E_纹理维度类型::e_CUBE:
						case E_纹理维度类型::e_CUBE_Array: {
							height = (宽度 / 3.0) * 4.0;
							break;
						}
						default:
							height *= float32(tex->m_Size.y) / float32(tex->m_Size.x);
							break;
					}
				}
			}
			e.m_UI->m_部件->f_setSize({ 宽度, height + 24 });
			e.m_UI->m_部件->f_setPos(pos);
			
			pos.y += height + (24 + S_UI主题::ui_面板圆角半径) * dpi;
			break;
		}

		default:
			e.m_UI->m_部件->f_setPos(推进左边);
			e.m_UI->m_部件->f_setSize({ 宽度, 组件高度 });
			break;
	}

	pos.y += (g上下间隙 + S_UI主题::ui_面板圆角半径 * 2) * dpi;
	

	return;

To_矢量部件布局:
	e.m_UI->m_部件->f_setPos(推进左边);
	e.m_UI->m_部件->f_setSize({ 宽度, 组件高度 * 矢量部件分量数量 });
	e.m_UI->m_部件->m_间隔宽度 = 1;

	pos.y += 组件高度 * 矢量部件分量数量;
	pos.y += (g上下间隙 + S_UI主题::ui_面板圆角半径) * dpi;
	
}

static void on_属性栏布局(C_Widget* self, C_Widget** w, uint32 num) {
	C_属性栏* 属性栏 = dynamic_cast<C_属性栏*>(self);
	
	float32 dpi = self->m_UIctx->m_DPI;
	float32 左边 = g两边间隙 * dpi;
	vec2 pos = { 左边, 属性栏->m_View->m_滚动量 + (g上下间隙 + 10) * dpi };
	
	
	float32 宽度 = 属性栏->m_View->m_手柄->f_getPos().x ;
	C_Widget* 当前父组件 = nullptr;
	for (auto& e : 属性栏->m_View->m_属性) {
		on_属性栏单个组件布局(属性栏->m_View, pos, e, 0, 宽度, dpi);
	}


	vec2 size = self->m_Size;
	size.x = S_UI主题::ui_拖拽手柄宽度 * dpi;
	float32 总高度 = pos.y + S_UI主题::ui_滚动条厚度 * 2 - 属性栏->m_View->m_滚动量;

	属性栏->m_View->m_手柄->f_setSize(size);
	属性栏->m_View->f_setSize({ 宽度, 总高度 });

	属性栏->m_滚动窗口->f_setSize({ 宽度, self->m_Size.y });
}

static void on_属性栏绘制(C_Widget* self, S_2D画布* 画布) {
	C_属性栏& box = *dynamic_cast<C_属性栏*>(self);

	box.m_View->m_背景 = f_vg_genConvex((*self), *画布, E_填充模式::e_填充面, E_图层混合模式::e_Normal);
	box.m_View->m_字符 = f_vg_genString((*self), *画布, E_填充模式::e_填充面, E_图层混合模式::e_Normal, u"雅黑");
	box.m_View->m_图标 = f_vg_genIco((*self), *画布, E_图层混合模式::e_Normal, E_填充模式::e_填充面);
}

static void on_属性栏变换(struct C_Widget* self) {
	C_属性栏& box = *dynamic_cast<C_属性栏*>(self);
	float32 dpi = self->m_UIctx->m_DPI;

	float32 上下间隙 = g上下间隙 * dpi;

	S_矢量绘制数据 矢量绘制数据;

	S_2DConvexRect rect{};
	rect.size = self->m_Size;
	rect.radius = {3 * dpi, 3 * dpi };
	矢量绘制数据.位置.emplace_back(vec2{});
	矢量绘制数据.区域.emplace_back(rect);
	矢量绘制数据.形状.emplace_back(&(box.m_UIctx->m_Ctx.m_几何图形->m_平面矩形));
	矢量绘制数据.颜色.emplace_back(S_主题颜色::uic_工作区页面背景 - S_RGBA8UI{4,4,4,0});

	bool 手柄展开 = box.m_View->m_手柄->m_ColorA.m_颜色.a != S_UI主题::uic_拖拽手柄.a;
	f_ui_draw_temple_拖放条手柄(box.m_View->m_手柄, 矢量绘制数据.区域, 矢量绘制数据.形状, 矢量绘制数据.颜色, 矢量绘制数据.位置, 手柄展开);

	

	auto e = box.m_View->f_get更新组件();
	for (uint32 i = 0; i < e.m_Num; ++i) {
		
		auto& prop = e.m_W[i]->m_自定义属性;
		rect.size = e.m_W[i]->m_Size;
		auto pos = e.m_W[i]->m_Pos;

		

		f_ui_drawTemple_PropsName(矢量绘制数据, prop, pos - vec2{0, 上下间隙}, {rect.size.x, 上下间隙});

		switch (e.m_W[i]->m_Type) {
			case E_值类型::e_Type_Operator: {
				f_ui_drawTemple_PropsOps(矢量绘制数据, e.m_W[i], prop, rect, pos);
				break;
			}

			case E_值类型::e_Type_I8:
			case E_值类型::e_Type_UI8:
			case E_值类型::e_Type_I32:
			case E_值类型::e_Type_UI32:
			case E_值类型::e_Type_F32:
			case E_值类型::e_Type_F16: 
			case E_值类型::e_Type_F64: 
			case E_值类型::e_Type_F128:
			case E_值类型::e_Type_UI64: {
				f_ui_drawTemple_PropsValue(矢量绘制数据, e.m_W[i], prop, rect, pos);
				break;
			}

			case E_值类型::e_Type_iVec2:
			case E_值类型::e_Type_iVec3:
			case E_值类型::e_Type_uVec3:
			case E_值类型::e_Type_iVec4:
			case E_值类型::e_Type_uVec4:
			case E_值类型::e_Type_Vec2:
			case E_值类型::e_Type_Vec3:
			case E_值类型::e_Type_Vec4:
			case E_值类型::e_Type_uVec2: {
				f_ui_drawTemple_PropsVec(矢量绘制数据, e.m_W[i], prop, rect, pos);
				break;
			}

			case E_值类型::e_Type_UI32位域枚举:
			case E_值类型::e_Type_UI32Ops: {
				f_ui_drawTemple_PropsUI32Flage(矢量绘制数据, e.m_W[i], prop, rect, pos);
				break;
			}
			case E_值类型::e_Type_Enum: {
				f_ui_drawTemple_PropsEnum(矢量绘制数据, e.m_W[i], prop, rect, pos);
				break;
			}

			case E_值类型::e_Type_ObjectContainerArray:
			case e_Type_ObjectContainerMap: {
				f_ui_drawTemple_PropsObjectContainer(矢量绘制数据, e.m_W[i], prop);
				break;
			}
		}
		
	}

	f_vg_tranform(*box.m_View->m_背景, 矢量绘制数据.位置.size(), 矢量绘制数据.位置.data());
	f_vg_drawConvex(*box.m_View->m_背景, 矢量绘制数据.形状.size(), 矢量绘制数据.形状.data(), 矢量绘制数据.区域.data());
	f_vg_color(*box.m_View->m_背景, 矢量绘制数据.颜色.size(), 矢量绘制数据.颜色.data());

	f_vg_drawString(*box.m_View->m_字符, 矢量绘制数据.字符文本, 矢量绘制数据.字符区域, 矢量绘制数据.字符颜色, 矢量绘制数据.对齐方式, {S_UI主题::ui_文字间隔, E_方向::e_横向 });


	uint32 图标数量 = 矢量绘制数据.图标名称.size();
	f_vg_drawIco(*box.m_View->m_图标, 图标数量, 矢量绘制数据.图标名称.data());
	f_vg_tranform(*box.m_View->m_图标, 图标数量, 矢量绘制数据.图标位置.data(), 矢量绘制数据.图标大小.data());
	f_vg_color(*box.m_View->m_图标, 图标数量, 矢量绘制数据.图标颜色.data());
}


static E_事件是否传递 on_属性栏内视口滚动(C_Widget* self, const S_鼠标& 鼠标) {
	C_属性栏* s = dynamic_cast<C_属性栏*>(self);
	
	float32 父组件大小 = self->m_Size.y;
	
	float32 步进 = s->m_View->m_滚动量 + C_Widget::g_鼠标.lZ * 40;
	self->m_更新绘制属性 = true;

	if (s->m_View->m_Size.y + 步进 <= 父组件大小) {
		步进 = (父组件大小 - s->m_View->m_Size.y);
	}
	if (步进 > 0) {
		s->m_View->m_滚动量 = 0;
		return E_事件是否传递::e_事件传递_继续;
	}

	s->m_View->m_滚动量 = 步进;
	
	return E_事件是否传递::e_事件传递_继续;
}


C_属性栏::C_属性栏(S_UI渲染环境& ctx) : C_Widget(&ctx) {
	
	m_View = new C_属性栏视口(ctx);
	m_View->f_setSize({ 200, 20 });
	m_View->m_布局方向 = E_方向::e_纵向;

	m_View->m_手柄			= f_ui_创建拖拽手柄(ctx, E_方向::e_纵向);
	m_View->m_手柄->mf_拖拽	= on_手柄拖动;
	m_View->m_手柄->f_setPos({ 200 - S_UI主题::ui_拖拽手柄宽度,0 });



	m_滚动窗口 = f_ui_创建滚动框(ctx, false, true, m_View);
	m_滚动窗口->f_setSize({ 256, 20 });
	m_滚动窗口->mf_鼠标滚轮 = nullptr;
	
	mf_布局 = on_属性栏布局;
	mf_绘制 = on_属性栏绘制;
	mf_变换 = on_属性栏变换;

	mf_鼠标滚轮 = on_属性栏内视口滚动;

	f_setSize({ 20, 20 });

	{
		f_添加子组件(m_滚动窗口);
		f_添加子组件(m_View->m_手柄);

		{
			m_View->f_切换方向(E_方向::e_纵向);
		}
	}
	
	f_widget_添加绘制画布(this);
}

void C_属性栏::f_打开() {
}

void C_属性栏::f_关闭() {
}

void C_属性栏::f_设置宽度(float32 w) {
	f_setW(w + S_UI主题::ui_拖拽手柄宽度);
	m_滚动窗口->f_setW(w);
}

void C_属性栏::f_构建属性部件(const std::vector<S_Props>& newProp) {
	m_View->f_构建属性部件(newProp);
	m_更新绘制属性 = true;
}

void C_属性栏::f_属性更新到组件() {
	auto e = m_View->f_get更新组件();
	for (uint32 i = 0; i < e.m_Num; ++i) {
		switch (e.m_W[i]->m_Type) {
			case E_值类型::e_Type_I8:
			case E_值类型::e_Type_UI8:
			case E_值类型::e_Type_I32:
			case E_值类型::e_Type_UI32:
			case E_值类型::e_Type_UI64:
			case E_值类型::e_Type_F32:
			
			case E_值类型::e_Type_iVec2:
			case E_值类型::e_Type_iVec3:
			case E_值类型::e_Type_iVec4:
			case E_值类型::e_Type_uVec2:
			case E_值类型::e_Type_uVec3:
			case E_值类型::e_Type_uVec4:
			case E_值类型::e_Type_Vec2:
			case E_值类型::e_Type_Vec3:
			case E_值类型::e_Type_Vec4: {
				e.m_W[i]->f_属性更新到组件();
				break;
			}
			default:
				break;
		}
	}
}


C_属性栏* f_创建属性边栏(S_UI渲染环境& ctx) {
	C_属性栏* 属性栏 = new C_属性栏(ctx);
	return 属性栏;
}




void f_属性栏_初始化() {
	//g属性右键菜单 = f_通用菜单_属性值右键菜单(ctx, on_属性右键菜单项事件);
	g属性右键菜单快捷键 = f_widget_init_鼠标键位映射();
	g属性右键菜单快捷键->event = on_打开属性右键菜单事件;
	g属性右键菜单快捷键->鼠标按键[0] = E_Input_鼠标按键::e_右键;
	g属性右键菜单快捷键->鼠标状态[0] = DEF_按键状态_按下;
	C_键位映射配置::f_添加全局操作键位((S_键位映射*)g属性右键菜单快捷键, u"数值组件弹出菜单");
}

void f_属性栏_清理() {
	//delete g属性右键菜单;
}









void on_状态栏布局(C_Widget* self, C_Widget** w, uint32 num) {
	C_状态条* 状态栏 = dynamic_cast<C_状态条*>(self);

	float32 dpi = 状态栏->m_UIctx->m_DPI;
	auto* p		= 状态栏->m_属性.data();
	uint32 pNum	= 状态栏->m_属性.size();


	float32 手柄宽度 = S_UI主题::ui_拖拽手柄宽度 * 0.7 * dpi;
	float32 状态栏高度 = g状态栏高度 * dpi;
	vec2 pos = { 5, 手柄宽度*0.5f };

	vec2 size = self->m_Size;
	size.y -= 手柄宽度;

	

	for (uint32 i = 0; i < num; ++i) {
		auto& e = p[i];
		auto& 组件 = *w[i];

		switch (组件.m_Type) {
		case E_值类型::e_Type_None:
			break;
		
		case E_值类型::e_Type_LayoutList: {
			break;
		}
		case E_值类型::e_Type_Operator: {
			if (e.m_布局方式 == E_布局方式::e_等比) {
				组件.f_setSize({ size.y, size.y });
				组件.m_是否延展 = {false, false};
			}
			else {
				组件.f_setSize({ 60 * dpi, 状态栏高度 });
			}
			组件.m_ColorA.m_颜色 = S_UI主题::uic_按钮;
			break;
		}

		case E_值类型::e_Type_LineText: {
			const auto& str = f_prop_LineStr(e);
			float32 width = f_vg_getStringSize(*状态栏->m_字符, str + e.m_Name, 状态栏高度, S_UI主题::ui_文字间隔 * dpi);
			组件.f_setSize({ width + 状态栏高度, 状态栏高度 });
			break;
		}
		
		case E_值类型::e_Type_UI32位域枚举:
		case E_值类型::e_Type_UI32Ops:
		case E_值类型::e_Type_Enum: {
			S_PropValueEnum& 枚举 = f_prop_enumItem(组件.m_自定义属性);

			vec2 枚举部件大小 = vec2{ g状态栏高度 * dpi, g状态栏高度 } - S_UI主题::ui_拖拽手柄宽度 * 0.5f;
			if (枚举.m_展开) {
				枚举部件大小.x *= p[i].m_值元素个数;
			}
			else {
				枚举部件大小.x = 200;
			}
			f_ui_set枚举选择框图标和文字是否绘制(p[i].m_UI->m_部件, true, false);
			f_ui_set枚举布局方向(&组件, E_方向::e_横向);
			组件.f_setSize(枚举部件大小);
			
			break;
		}
		case E_值类型::e_Type_Bool:
			组件.f_setSize({ 18, 18 });
			break;

		case E_值类型::e_Type_I16:
		case E_值类型::e_Type_I32:
		case E_值类型::e_Type_I64:
		case E_值类型::e_Type_F32:
		case E_值类型::e_Type_F64:
			组件.f_setSize({ 100, 状态栏高度 });
			break;


		
		case E_值类型::e_Type_iVec2:
		case E_值类型::e_Type_iVec3:
		case E_值类型::e_Type_iVec4:
		case E_值类型::e_Type_uVec2:
		case E_值类型::e_Type_uVec3:
		case E_值类型::e_Type_uVec4:
		case E_值类型::e_Type_Vec2:
		case E_值类型::e_Type_Vec3:
		case E_值类型::e_Type_Vec4:
			组件.f_setSize({150, 状态栏高度 });
			f_ui_setVec布局方向(&组件, E_方向::e_横向);
			break;


		case E_值类型::e_Type_Bool_1D: {
			组件.f_setSize({p[i].m_值元素个数 * 状态栏高度, 状态栏高度 });
			break;
		}

		case E_值类型::e_Type_映射引用_2D:
		case E_值类型::e_Type_MapPtr_Array1D: {
			组件.f_setSize({ 200, 状态栏高度 });
			break;
		}

		case E_值类型::e_Type_ObjectContainerArray:
		case E_值类型::e_Type_ObjectContainerMap: {
			e.m_UI->m_部件->f_setPos(pos);
			e.m_UI->m_部件->f_setSize({ 250*dpi, 状态栏高度 });
			break;
		}
		default:
			//p[i].m_部件->f_setLoc(pos);
			//p[i].m_部件->f_setSize({ self->m_Size.x - 100 - S_UI主题::ui_滚动条厚度 * 2, 18 });
			break;
		}
	}
	

	auto e = 状态栏->f_get更新组件();
	
	if(e.m_Num) f_HBOX布局(pos, size, e.m_W, e.m_Num, 8*dpi);

}




static void on_状态栏绘制(C_Widget* self, S_2D画布* 画布) {
	C_状态条& box = *dynamic_cast<C_状态条*>(self);
	
	box.m_背景 = f_vg_genConvex((*self), *画布, E_填充模式::e_填充面, E_图层混合模式::e_Normal);
	box.m_字符 = f_vg_genString((*self), *画布, E_填充模式::e_填充面, E_图层混合模式::e_Normal, u"雅黑");
	box.m_图标 = f_vg_genIco((*self), *画布, E_图层混合模式::e_Normal, E_填充模式::e_填充面);
}

static void on_状态条变换(C_Widget* self) {
	C_状态条& box = *dynamic_cast<C_状态条*>(self);

	float32 dpi = self->m_UIctx->m_DPI;


	S_矢量绘制数据 矢量绘制数据;

	S_2DConvexRect rect{};
	rect.size = self->m_Size;
	rect.radius = {3 * dpi, 3 * dpi };
	矢量绘制数据.位置.emplace_back(vec2{});
	矢量绘制数据.区域.emplace_back(rect);
	矢量绘制数据.形状.emplace_back(&(box.m_UIctx->m_Ctx.m_几何图形->m_平面矩形));
	矢量绘制数据.颜色.emplace_back(S_主题颜色::uic_状态条背景);


	auto e = box.f_get更新组件();
	for (uint32 i = 0; i < e.m_Num; ++i) {
		rect.size = e.m_W[i]->m_Size;
		auto pos = e.m_W[i]->m_Pos;

		auto& prop = e.m_W[i]->m_自定义属性;
		
		switch (e.m_W[i]->m_Type) {
			case E_值类型::e_Type_Operator: {
				f_ui_drawTemple_PropsOps(矢量绘制数据, e.m_W[i], prop, rect, pos);
				break;
			}
			case E_值类型::e_Type_LineText: {
				f_ui_drawTemple_PropsLineStr(矢量绘制数据, e.m_W[i], prop, rect, pos);
				break;
			}
			case E_值类型::e_Type_I8:
			case E_值类型::e_Type_UI8:
			case E_值类型::e_Type_I32:
			case E_值类型::e_Type_UI32:
			case E_值类型::e_Type_F32:
			case E_值类型::e_Type_F16: 
			case E_值类型::e_Type_F64: 
			case E_值类型::e_Type_F128:
			case E_值类型::e_Type_UI64: {
				f_ui_drawTemple_PropsValue(矢量绘制数据, e.m_W[i], prop, rect, pos);
				break;
			}

			case E_值类型::e_Type_iVec2:
			case E_值类型::e_Type_iVec3:
			case E_值类型::e_Type_uVec3:
			case E_值类型::e_Type_iVec4:
			case E_值类型::e_Type_uVec4:
			case E_值类型::e_Type_Vec2:
			case E_值类型::e_Type_Vec3:
			case E_值类型::e_Type_Vec4:
			case E_值类型::e_Type_uVec2: {
				f_ui_drawTemple_PropsVec(矢量绘制数据, e.m_W[i], prop, rect, pos);
				break;
			}
			case E_值类型::e_Type_UI32位域枚举:
			case E_值类型::e_Type_UI32Ops: {
				f_ui_drawTemple_PropsUI32Flage(矢量绘制数据, e.m_W[i], prop, rect, pos);
				break;
			}
			case E_值类型::e_Type_Enum: {
				f_ui_drawTemple_PropsEnum(矢量绘制数据, e.m_W[i], prop, rect, pos);
				break;
			}
			case E_值类型::e_Type_ObjectContainerArray:
			case e_Type_ObjectContainerMap: {
				f_ui_drawTemple_PropsObjectContainer(矢量绘制数据, e.m_W[i], prop);
				break;
			}
		}
	}

	f_vg_tranform(*box.m_背景, 矢量绘制数据.位置.size(), 矢量绘制数据.位置.data());
	f_vg_drawConvex(*box.m_背景, 矢量绘制数据.形状.size(), 矢量绘制数据.形状.data(), 矢量绘制数据.区域.data());
	f_vg_color(*box.m_背景, 矢量绘制数据.颜色.size(), 矢量绘制数据.颜色.data());

	f_vg_drawString(*box.m_字符, 矢量绘制数据.字符文本, 矢量绘制数据.字符区域, 矢量绘制数据.字符颜色, E_对齐方式::e_据中对齐, {S_UI主题::ui_文字间隔, E_方向::e_横向 });

	
	uint32 图标数量 = 矢量绘制数据.图标名称.size();
	f_vg_drawIco(*box.m_图标, 图标数量, 矢量绘制数据.图标名称.data());
	f_vg_tranform(*box.m_图标, 图标数量, 矢量绘制数据.图标位置.data(), 矢量绘制数据.图标大小.data());
	f_vg_color(*box.m_图标, 图标数量, 矢量绘制数据.图标颜色.data());
}

C_状态条::C_状态条(S_UI渲染环境& ctx) :C_属性栏视口(ctx) {
	m_WName = u"状态条";
	m_TypeName = "C_状态条";

	f_setSize({ g状态栏高度, g状态栏高度+3 });

	mf_布局 = on_状态栏布局;
	mf_绘制 = on_状态栏绘制;
	mf_变换 = on_状态条变换;
	
	f_切换方向(E_方向::e_横向);

	f_widget_添加绘制画布(this);
}

void C_状态条::f_构建属性部件(const std::vector<S_Props>& newProp, C_状态条* 分身) {
	C_属性栏视口::f_构建属性部件(newProp);
	m_更新绘制属性 = true;
}

S_Props& C_状态条::f_get属性(uint16 offset) {
	return m_属性[offset];
}





void f_属性栏_刷新属性绘制() {
	return;
	for (auto& e : g_当前所有属性栏) {
		if(e->m_被裁剪) continue;

		for (auto& p : e->m_属性) {
			p.m_UI->m_部件->m_更新绘制属性 = true;

			switch (p.m_Type) {
				case E_值类型::e_Type_F32:
				case E_值类型::e_Type_I8:
				case E_值类型::e_Type_I16:
				case E_值类型::e_Type_I32:
				case E_值类型::e_Type_I64:
				case E_值类型::e_Type_UI8:
				case E_值类型::e_Type_UI16:
				case E_值类型::e_Type_UI32:
				case E_值类型::e_Type_UI64:
					f_ui_刷新数值编辑框绘制(p.m_UI->m_部件);
					break;

				case E_值类型::e_Type_Vec2:
				case E_值类型::e_Type_Vec3:
				case E_值类型::e_Type_Vec4:
				case E_值类型::e_Type_iVec2:
				case E_值类型::e_Type_iVec3:
				case E_值类型::e_Type_iVec4:
				case E_值类型::e_Type_Vec2_1D:
				case E_值类型::e_Type_Vec3_1D:
				case E_值类型::e_Type_Vec4_1D:
				case E_值类型::e_Type_iVec2_1D:
				case E_值类型::e_Type_iVec3_1D:
				//case E_值类型::e_Type_iVec4_1D:
					f_ui_刷新vec编辑框文本绘制(p.m_UI->m_部件);
					break;

				case E_值类型::e_Type_UI32位域枚举:
				case E_值类型::e_Type_UI32Ops:
				case E_值类型::e_Type_Enum: {
					
					break;
				}
				case E_值类型::e_Type_LineText:
					break;

				case E_值类型::e_Type_TexProp:
					f_ui_刷新图像框属性(p.m_UI->m_部件);
					break;
				default:
					break;
			}
		}
	}
}

